package com.chunlin.package3;

//当一个事物的内部，还有一个部分需要一个完整的结构进行描述，而这个内部的完整的结构又只为外部事物提供服
//务，那么这个内部的完整结构最好使用内部类。在 Java 中，可以将一个类定义在另一个类或者一个方法的内部，
//前者称为内部类，后者称为外部类。内部类也是封装的一种体现
//内部类和外部类共用同一个java源文件，但是经过编译之后，内部类会形成单独的字节码文件

//根据内部类定义的位置不同，一般可以分为以下几种形式：
//1. 成员内部类(普通内部类：未被static修饰的成员内部类 和 静态内部类：被static修饰的成员内部类)
//2. 局部内部类(不谈修饰符)、匿名内部类
//注意：内部类其实日常开发中使用并不是非常多，些库中的代码时候可能会遇到的比较多，日常开始中使用最多的是匿名内部类
public class InnerClass {
    private int a;
    static int b;
    int c;

    int e = 10;

    public void methodA() {
        a = 10;
        System.out.println(a);
    }

    public static void methodB() {
        System.out.println(b);
    }


    // 成员位置定义：未被static修饰 --->实例内部类
    //在外部类中，内部类定义位置与外部类成员所处的位置相同，因此称为成员内部类
    public class InnerClass1 {
        private int c;
        private int d;

        public void methodInner() {
            // 在实例内部类中可以直接访问外部类中：任意访问限定符修饰的成员
            //这是因为每个实例内部类对象都有一个隐含的引用指向创建它的外部类对象。通过这个引用，内部类的方法可以直接访问外部类的成员（包括私有成员）
            a = 10;
            b = 20;
            methodA();
            methodB();

            // 如果外部类和实例内部类中具有相同名称成员时，优先访问的是内部类自己的
            c = 30;
            System.out.println("c = " + c);

            // 如果要访问外部类同名成员时候，必须：外部类名称.this.同名成员名字
            InnerClass.this.c = 40;
            System.out.println("c = " + InnerClass.this.c);
        }

        public void testInner() {
            c = 80;
            d = 90;
            System.out.println("c " + c);
            System.out.println("d " + d);
        }
    }

    public void accessInnerClass1() {
        // 无法直接访问 InnerClass1 的成员
        //  d = 10;

        //必须先创建InnerClass1实例,才能进行访问
        InnerClass1 innerClass1 = new InnerClass1();
        innerClass1.d = 10;
        innerClass1.testInner();
    }

    // 成员位置定义：被static修饰 ---> 静态内部类
    static class InnerClass2 {
        private InnerClass outer;
        public InnerClass2(InnerClass outer) {
            this.outer = outer;
        }

        public void methodInner() {
            // 在内部类中只能访问外部类的静态成员
            // 编译失败，因为a不是静态类成员变量
            // a = 100;

            b = 200;
            System.out.println("b = " + b);

            //编译失败, 因为methodA不是静态类成员方法
            //methodA();
            methodB();
        }

        public void methodInner2() {
            outer.a = 100;
            System.out.println("a = " + outer.a);

            outer.methodA();
        }
    }

    //【注意事项】
    //1. 局部内部类只能在所定义的方法体内部使用
    //2. 不能被public、static等修饰符修饰
    //3. 编译器也有自己独立的字节码文件，命名格式：外部类名字$数字内部类名字.class
    //4. 几乎不会使用
    public void method() {
        int f = 20;
        // 方法中也可以定义内部类 ---> 局部内部类：几乎不用
        // 局部内部类：定义在方法体内部
        // 不能被public、static等访问限定符修饰
        class InnerClass3 {
            public void methodInner() {
                System.out.println("e = " + e);
                System.out.println("f = " + f);
            }
        }

        // 只能在该方法体内部使用，其他位置都不能用
        InnerClass3 innerClass3 = new InnerClass3();
        innerClass3.methodInner();
    }

    //对实例内部类进行测试
    public void testInstanceInnerClass() {
        // 外部类：对象创建 以及 成员访问
        InnerClass innerClass = new InnerClass();
        System.out.println(innerClass.a);
        System.out.println(innerClass.b);
        System.out.println(innerClass.c);
        innerClass.methodA();
        innerClass.methodB();

        System.out.println("=============实例内部类的访问=============");
        // 要访问实例内部类中成员，必须要创建实例内部类的对象
        // 而普通内部类定义与外部类成员定义位置相同，因此创建实例内部类对象时必须借助外部类

        //创建实例内部类对象
        InnerClass.InnerClass1 innerClass1 = new InnerClass().new InnerClass1();
        innerClass1.methodInner();

        innerClass.accessInnerClass1();

        //【注意事项】
        //1. 外部类中的任何成员都可以在实例内部类方法中直接访问
        //2. 实例内部类所处的位置与外部类成员位置相同，因此也受public、private等访问限定符的约束
        //3. 在实例内部类方法中访问同名的成员时，优先访问自己的，如果要访问外部类同名的成员，必须：外部类名
        //称.this.同名成员 来访问
        //4. 实例内部类对象必须在先有外部类对象前提下才能创建
        //5. 实例内部类的非静态方法中包含了一个指向外部类对象的引用
        //6. 外部类中，不能直接访问实例内部类中的成员，如果要访问必须先要创建内部类的对象
    }

    public void testStaticInnerClass(InnerClass innerClass) {
        InnerClass.InnerClass2 innerClass2= new InnerClass.InnerClass2(innerClass);
//        innerClass2.methodInner();

        innerClass2.methodInner2();
        //【注意事项】
        //1. 在静态内部类中只能访问外部类中的静态成员,但是如果确实想访问
        // 静态内部类的构造函数可以以外部类作为参数,这样就可以访问到外部类的非静态成员
        //2. 创建静态内部类对象时，不需要先创建外部类对象
    }

    public static void main(String[] args) {
        InnerClass innerClass = new InnerClass();
//        innerClass.testInstanceInnerClass();

//        innerClass.testStaticInnerClass(innerClass);

        innerClass.method();
    }
}
